from flask import Blueprint, request, jsonify, current_app
from flasgger import swag_from
from sqlalchemy import func
from app import db
from app.models.venue import Venue
from app.utils.response import success_response, error_response

venue_categories_bp = Blueprint('venue_categories', __name__)

@venue_categories_bp.route('/venue-categories', methods=['GET'])
@swag_from({
    'tags': ['公共接口'],
    'summary': '获取体育场馆分类列表',
    'description': '获取数据库中所有可用的体育场馆分类信息，包括分类名称和每个分类下的场馆数量统计。无需登录即可访问。请求示例：GET /api/v1/common/venue-categories',
    'parameters': [
        {
            'name': 'include_count',
            'in': 'query',
            'type': 'boolean',
            'default': True,
            'description': '是否包含每个分类的场馆数量统计，默认为true'
        },
        {
            'name': 'only_active',
            'in': 'query',
            'type': 'boolean',
            'default': True,
            'description': '是否只返回状态为开放的场馆分类，默认为true'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'total_categories': {'type': 'integer', 'description': '分类总数'},
                            'categories': {
                                'type': 'array',
                                'description': '分类列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'type': {'type': 'string', 'description': '分类名称'},
                                        'venue_count': {'type': 'integer', 'description': '该分类下的场馆数量（仅当include_count=true时返回）'},
                                        'active_venue_count': {'type': 'integer', 'description': '该分类下开放状态的场馆数量（仅当include_count=true时返回）'}
                                    }
                                }
                            },
                            'statistics': {
                                'type': 'object',
                                'description': '统计信息',
                                'properties': {
                                    'total_venues': {'type': 'integer', 'description': '场馆总数'},
                                    'active_venues': {'type': 'integer', 'description': '开放状态场馆总数'},
                                    'inactive_venues': {'type': 'integer', 'description': '关闭状态场馆总数'}
                                }
                            }
                        }
                    }
                }
            }
        },
        500: {
            'description': '服务器内部错误'
        }
    }
})
def get_venue_categories():
    """获取体育场馆分类列表"""
    try:
        # 获取查询参数
        include_count = request.args.get('include_count', 'true').lower() == 'true'
        only_active = request.args.get('only_active', 'true').lower() == 'true'
        
        # 构建基础查询条件
        base_filter = Venue.is_deleted == False
        if only_active:
            base_filter = db.and_(base_filter, Venue.status == 1)
        
        if include_count:
            # 查询分类及其数量统计
            categories_query = db.session.query(
                Venue.type,
                func.count(Venue.id).label('total_count'),
                func.sum(db.case((Venue.status == 1, 1), else_=0)).label('active_count')
            ).filter(
                Venue.is_deleted == False,
                Venue.type.isnot(None),
                Venue.type != ''
            ).group_by(Venue.type).order_by(Venue.type)
            
            # 如果只要开放状态的分类，则过滤掉没有开放场馆的分类
            if only_active:
                categories_query = categories_query.having(func.sum(db.case((Venue.status == 1, 1), else_=0)) > 0)
            
            categories_data = []
            total_venues = 0
            active_venues = 0
            
            for venue_type, total_count, active_count in categories_query.all():
                category_info = {
                    'type': venue_type,
                    'venue_count': int(total_count),
                    'active_venue_count': int(active_count or 0)
                }
                categories_data.append(category_info)
                total_venues += int(total_count)
                active_venues += int(active_count or 0)
            
            # 统计信息
            statistics = {
                'total_venues': total_venues,
                'active_venues': active_venues,
                'inactive_venues': total_venues - active_venues
            }
            
        else:
            # 只查询分类名称，不统计数量
            categories_query = db.session.query(Venue.type).filter(
                base_filter,
                Venue.type.isnot(None),
                Venue.type != ''
            ).distinct().order_by(Venue.type)
            
            categories_data = [
                {'type': venue_type} 
                for (venue_type,) in categories_query.all()
            ]
            
            # 简单统计
            total_count = db.session.query(func.count(Venue.id)).filter(Venue.is_deleted == False).scalar()
            active_count = db.session.query(func.count(Venue.id)).filter(
                Venue.is_deleted == False, 
                Venue.status == 1
            ).scalar()
            
            statistics = {
                'total_venues': total_count,
                'active_venues': active_count,
                'inactive_venues': total_count - active_count
            }
        
        # 构建响应数据
        response_data = {
            'total_categories': len(categories_data),
            'categories': categories_data,
            'statistics': statistics
        }
        
        return success_response(response_data, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取场馆分类失败: {str(e)}")
        return error_response('获取失败', 500)


@venue_categories_bp.route('/venue-categories/<category_type>', methods=['GET'])
@swag_from({
    'tags': ['公共接口'],
    'summary': '获取指定分类的场馆列表',
    'description': '根据分类类型获取该分类下所有场馆的详细信息，支持分页查询。无需登录即可访问。请求示例：GET /api/v1/common/venue-categories/篮球场?page=1&per_page=10',
    'parameters': [
        {
            'name': 'category_type',
            'in': 'path',
            'type': 'string',
            'required': True,
            'description': '场馆分类类型，如：篮球场、足球场、羽毛球场等'
        },
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码，从1开始'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 10,
            'description': '每页数量，最大50'
        },
        {
            'name': 'only_active',
            'in': 'query',
            'type': 'boolean',
            'default': True,
            'description': '是否只返回开放状态的场馆，默认为true'
        },
        {
            'name': 'location',
            'in': 'query',
            'type': 'string',
            'description': '按地区筛选场馆'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'category_type': {'type': 'string', 'description': '查询的分类类型'},
                            'total': {'type': 'integer', 'description': '该分类下场馆总数'},
                            'page': {'type': 'integer', 'description': '当前页码'},
                            'pages': {'type': 'integer', 'description': '总页数'},
                            'per_page': {'type': 'integer', 'description': '每页数量'},
                            'venues': {
                                'type': 'array',
                                'description': '场馆列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer', 'description': '场馆ID'},
                                        'name': {'type': 'string', 'description': '场馆名称'},
                                        'type': {'type': 'string', 'description': '场馆类型'},
                                        'address': {'type': 'string', 'description': '场馆地址'},
                                        'location': {'type': 'string', 'description': '所在区域'},
                                        'latitude': {'type': 'number', 'description': '纬度'},
                                        'longitude': {'type': 'number', 'description': '经度'},
                                        'description': {'type': 'string', 'description': '场馆描述'},
                                        'images': {'type': 'array', 'items': {'type': 'string'}, 'description': '场馆图片列表'},
                                        'contact_phone': {'type': 'string', 'description': '联系电话'},
                                        'open_time': {'type': 'string', 'description': '营业时间'},
                                        'max_capacity': {'type': 'integer', 'description': '最大容量'},
                                        'status': {'type': 'integer', 'description': '状态：0关闭，1开放'},
                                        'created_at': {'type': 'string', 'description': '创建时间'}
                                    }
                                }
                            }
                        }
                    }
                }
            }
        },
        404: {
            'description': '分类不存在或没有找到场馆'
        },
        500: {
            'description': '服务器内部错误'
        }
    }
})
def get_venues_by_category(category_type):
    """根据分类获取场馆列表"""
    try:
        # 获取查询参数
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 10, type=int), 50)
        only_active = request.args.get('only_active', 'true').lower() == 'true'
        location = request.args.get('location', '').strip()
        
        # 构建查询条件
        query_filter = db.and_(
            Venue.is_deleted == False,
            Venue.type == category_type
        )
        
        if only_active:
            query_filter = db.and_(query_filter, Venue.status == 1)
        
        if location:
            query_filter = db.and_(query_filter, Venue.location.like(f'%{location}%'))
        
        # 构建查询
        query = Venue.query.filter(query_filter)
        
        # 分页查询
        pagination = query.order_by(Venue.created_at.desc()).paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        if pagination.total == 0:
            return error_response(f'分类"{category_type}"下没有找到场馆', 404)
        
        # 转换为字典格式
        venues_data = [venue.to_dict() for venue in pagination.items]
        
        response_data = {
            'category_type': category_type,
            'total': pagination.total,
            'page': page,
            'pages': pagination.pages,
            'per_page': per_page,
            'venues': venues_data
        }
        
        return success_response(response_data, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取分类场馆列表失败: {str(e)}")
        return error_response('获取失败', 500) 